home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 27 / CU Amiga Magazine's Super CD-ROM 27 (1998)(EMAP Images)(GB)[!][issue 1998-10].iso / CUCD / Programming / Mesa / src / api1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-02  |  51.8 KB  |  2,018 lines
  1. /* $Id: api1.c,v 1.3 1997/11/05 03:25:52 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.5
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * api1.c
  26.  *
  27.  * Version 1.0  27 Jun 1998
  28.  * by Jarno van der Linden
  29.  * jarno@kcbbs.gen.nz
  30.  *
  31.  * File created from api1.c ver 1.3 and gl.h ver 1.26 using GenProtos
  32.  *
  33.  */
  34.  
  35.  
  36. #ifdef PC_HEADER
  37. #include "all.h"
  38. #else
  39. #include <stdio.h>
  40. #include <stdlib.h>
  41. #include "api.h"
  42. #include "bitmap.h"
  43. #include "context.h"
  44.  
  45. #include "drawpix.h"
  46.  
  47. #include "eval.h"
  48. #include "image.h"
  49. #include "macros.h"
  50. #include "matrix.h"
  51. #include "teximage.h"
  52. #include "types.h"
  53. #include "vb.h"
  54. #endif
  55.  
  56.  
  57.  
  58.  
  59. __asm __saveds void APIENTRY glAccum( register __d0 GLenum op, register __fp0 GLfloat value )
  60. {
  61.    GET_CONTEXT;
  62.    CHECK_CONTEXT;
  63.    (*CC->API.Accum)(CC, op, value);
  64. }
  65.  
  66.  
  67. __asm __saveds void APIENTRY glAlphaFunc( register __d0 GLenum func, register __fp0 GLclampf ref )
  68. {
  69.    GET_CONTEXT;
  70.    CHECK_CONTEXT;
  71.    (*CC->API.AlphaFunc)(CC, func, ref);
  72. }
  73.  
  74.  
  75. __asm __saveds GLboolean APIENTRY glAreTexturesResident( register __d0 GLsizei n, register __a0 const GLuint *textures,
  76.                                                          register __a1 GLboolean *residences )
  77. {
  78.    GET_CONTEXT;
  79.    CHECK_CONTEXT_RETURN(GL_FALSE);
  80.    return (*CC->API.AreTexturesResident)(CC, n, textures, residences);
  81. }
  82.  
  83.  
  84. __asm __saveds void APIENTRY glArrayElement( register __d0 GLint i )
  85. {
  86.    GET_CONTEXT;
  87.    CHECK_CONTEXT;
  88.    (*CC->API.ArrayElement)(CC, i);
  89. }
  90.  
  91.  
  92. __asm __saveds void APIENTRY glBegin( register __d0 GLenum mode )
  93. {
  94.    GET_CONTEXT;
  95.    CHECK_CONTEXT;
  96.    (*CC->API.Begin)( CC, mode );
  97. }
  98.  
  99.  
  100. __asm __saveds void APIENTRY glBindTexture( register __d0 GLenum target, register __d1 GLuint texture )
  101. {
  102.    GET_CONTEXT;
  103.    CHECK_CONTEXT;
  104.    (*CC->API.BindTexture)(CC, target, texture);
  105. }
  106.  
  107.  
  108. __asm __saveds void APIENTRY glBitmapA(register __a0 void *vargs)
  109. {
  110.     struct glBitmapArgs {
  111.         GLsizei width;
  112.         GLsizei height;
  113.         GLfloat xorig;
  114.         GLfloat yorig;
  115.         GLfloat xmove;
  116.         GLfloat ymove;
  117.         GLubyte *bitmap;
  118.     } *args;
  119.  
  120.     args = (struct glBitmapArgs *)vargs;
  121.  
  122.     glBitmap(args->width, args->height, args->xorig, args->yorig, args->xmove, args->ymove, args->bitmap);
  123. }
  124.  
  125.  
  126. __asm __saveds void APIENTRY glBitmap( register __d0 GLsizei width, register __d1 GLsizei height,
  127.                                        register __fp0 GLfloat xorig, register __fp1 GLfloat yorig,
  128.                                        register __fp2 GLfloat xmove, register __fp3 GLfloat ymove,
  129.                                        register __a0 const GLubyte *bitmap )
  130. {
  131.    GET_CONTEXT;
  132.    CHECK_CONTEXT;
  133.    if (!CC->CompileFlag) {
  134.       /* execute only, try optimized case where no unpacking needed */
  135.       if (   CC->Unpack.LsbFirst==GL_FALSE
  136.           && CC->Unpack.Alignment==1
  137.           && CC->Unpack.RowLength==0
  138.           && CC->Unpack.SkipPixels==0
  139.           && CC->Unpack.SkipRows==0) {
  140.          /* Special case: no unpacking needed */
  141.          struct gl_image image;
  142.          image.Width = width;
  143.          image.Height = height;
  144.          image.Components = 0;
  145.          image.Type = GL_BITMAP;
  146.          image.Format = GL_COLOR_INDEX;
  147.          image.Data = (GLvoid *) bitmap;
  148.          (*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
  149.                              xmove, ymove, &image );
  150.       }
  151.       else {
  152.          struct gl_image *image;
  153.          image = gl_unpack_bitmap( CC, width, height, bitmap );
  154.          (*CC->Exec.Bitmap)( CC, width, height, xorig, yorig,
  155.                              xmove, ymove, image );
  156.          if (image) {
  157.             gl_free_image( image );
  158.          }
  159.       }
  160.    }
  161.    else {
  162.       /* compile and maybe execute */
  163.       struct gl_image *image;
  164.       image = gl_unpack_bitmap( CC, width, height, bitmap );
  165.       (*CC->API.Bitmap)(CC, width, height, xorig, yorig, xmove, ymove, image );
  166.    }
  167. }
  168.  
  169.  
  170. __asm __saveds void APIENTRY glBlendFunc( register __d0 GLenum sfactor, register __d1 GLenum dfactor )
  171. {
  172.    GET_CONTEXT;
  173.    CHECK_CONTEXT;
  174.    (*CC->API.BlendFunc)(CC, sfactor, dfactor);
  175. }
  176.  
  177.  
  178. __asm __saveds void APIENTRY glCallList( register __d0 GLuint list )
  179. {
  180.    GET_CONTEXT;
  181.    CHECK_CONTEXT;
  182.    (*CC->API.CallList)(CC, list);
  183. }
  184.  
  185.  
  186. __asm __saveds void APIENTRY glCallLists( register __d0 GLsizei n, register __d1 GLenum type, register __a0 const GLvoid *lists )
  187. {
  188.    GET_CONTEXT;
  189.    CHECK_CONTEXT;
  190.    (*CC->API.CallLists)(CC, n, type, lists);
  191. }
  192.  
  193.  
  194. __asm __saveds void APIENTRY glClear( register __d0 GLbitfield mask )
  195. {
  196.    GET_CONTEXT;
  197.    CHECK_CONTEXT;
  198.    (*CC->API.Clear)(CC, mask);
  199. }
  200.  
  201.  
  202. __asm __saveds void APIENTRY glClearAccum( register __fp0 GLfloat red, register __fp1 GLfloat green,
  203.                                            register __fp2 GLfloat blue, register __fp3 GLfloat alpha )
  204. {
  205.    GET_CONTEXT;
  206.    CHECK_CONTEXT;
  207.    (*CC->API.ClearAccum)(CC, red, green, blue, alpha);
  208. }
  209.  
  210.  
  211.  
  212. __asm __saveds void APIENTRY glClearIndex( register __fp0 GLfloat c )
  213. {
  214.    GET_CONTEXT;
  215.    CHECK_CONTEXT;
  216.    (*CC->API.ClearIndex)(CC, c);
  217. }
  218.  
  219.  
  220. __asm __saveds void APIENTRY glClearColor( register __fp0 GLclampf red,
  221.                                            register __fp1 GLclampf green,
  222.                                            register __fp2 GLclampf blue,
  223.                                            register __fp3 GLclampf alpha )
  224. {
  225.    GET_CONTEXT;
  226.    CHECK_CONTEXT;
  227.    (*CC->API.ClearColor)(CC, red, green, blue, alpha);
  228. }
  229.  
  230.  
  231. __asm __saveds void APIENTRY glClearDepth( register __fp0 GLclampd depth )
  232. {
  233.    GET_CONTEXT;
  234.    CHECK_CONTEXT;
  235.    (*CC->API.ClearDepth)( CC, depth );
  236. }
  237.  
  238.  
  239. __asm __saveds void APIENTRY glClearStencil( register __d0 GLint s )
  240. {
  241.    GET_CONTEXT;
  242.    CHECK_CONTEXT;
  243.    (*CC->API.ClearStencil)(CC, s);
  244. }
  245.  
  246.  
  247. __asm __saveds void APIENTRY glClipPlane( register __d0 GLenum plane, register __a0 const GLdouble *equation )
  248. {
  249.    GLfloat eq[4];
  250.    GET_CONTEXT;
  251.    CHECK_CONTEXT;
  252.    eq[0] = (GLfloat) equation[0];
  253.    eq[1] = (GLfloat) equation[1];
  254.    eq[2] = (GLfloat) equation[2];
  255.    eq[3] = (GLfloat) equation[3];
  256.    (*CC->API.ClipPlane)(CC, plane, eq );
  257. }
  258.  
  259.  
  260. __asm __saveds void APIENTRY glColor3b( register __d0 GLbyte red, register __d1 GLbyte green, register __d2 GLbyte blue )
  261. {
  262.    GET_CONTEXT;
  263.    (*CC->API.Color3f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  264.                        BYTE_TO_FLOAT(blue) );
  265. }
  266.  
  267.  
  268. __asm __saveds void APIENTRY glColor3d( register __fp0 GLdouble red, register __fp1 GLdouble green, register __fp2 GLdouble blue )
  269. {
  270.    GET_CONTEXT;
  271.    (*CC->API.Color3f)( CC, (GLfloat) red, (GLfloat) green, (GLfloat) blue );
  272. }
  273.  
  274.  
  275. __asm __saveds void APIENTRY glColor3f( register __fp0 GLfloat red, register __fp1 GLfloat green, register __fp2 GLfloat blue )
  276. {
  277.    GET_CONTEXT;
  278.    (*CC->API.Color3f)( CC, red, green, blue );
  279. }
  280.  
  281.  
  282. __asm __saveds void APIENTRY glColor3i( register __d0 GLint red, register __d1 GLint green, register __d2 GLint blue )
  283. {
  284.    GET_CONTEXT;
  285.    (*CC->API.Color3f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  286.                        INT_TO_FLOAT(blue) );
  287. }
  288.  
  289.  
  290. __asm __saveds void APIENTRY glColor3s( register __d0 GLshort red, register __d1 GLshort green, register __d2 GLshort blue )
  291. {
  292.    GET_CONTEXT;
  293.    (*CC->API.Color3f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  294.                        SHORT_TO_FLOAT(blue) );
  295. }
  296.  
  297.  
  298. __asm __saveds void APIENTRY glColor3ub( register __d0 GLubyte red, register __d1 GLubyte green, register __d2 GLubyte blue )
  299. {
  300.    GET_CONTEXT;
  301.    (*CC->API.Color4ub)( CC, red, green, blue, 255 );
  302. }
  303.  
  304.  
  305. __asm __saveds void APIENTRY glColor3ui( register __d0 GLuint red, register __d1 GLuint green, register __d2 GLuint blue )
  306. {
  307.    GET_CONTEXT;
  308.    (*CC->API.Color3f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
  309.                        UINT_TO_FLOAT(blue) );
  310. }
  311.  
  312.  
  313. __asm __saveds void APIENTRY glColor3us( register __d0 GLushort red, register __d1 GLushort green, register __d2 GLushort blue )
  314. {
  315.    GET_CONTEXT;
  316.    (*CC->API.Color3f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
  317.                        USHORT_TO_FLOAT(blue) );
  318. }
  319.  
  320.  
  321. __asm __saveds void APIENTRY glColor4b( register __d0 GLbyte red, register __d1 GLbyte green, register __d2 GLbyte blue, register __d3 GLbyte alpha )
  322. {
  323.    GET_CONTEXT;
  324.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(red), BYTE_TO_FLOAT(green),
  325.                        BYTE_TO_FLOAT(blue), BYTE_TO_FLOAT(alpha) );
  326. }
  327.  
  328.  
  329. __asm __saveds void APIENTRY glColor4d( register __fp0 GLdouble red, register __fp1 GLdouble green, register __fp2 GLdouble blue, register __fp3 GLdouble alpha )
  330. {
  331.    GET_CONTEXT;
  332.    (*CC->API.Color4f)( CC, (GLfloat) red, (GLfloat) green,
  333.                        (GLfloat) blue, (GLfloat) alpha );
  334. }
  335.  
  336.  
  337. __asm __saveds void APIENTRY glColor4f( register __fp0 GLfloat red, register __fp1 GLfloat green, register __fp2 GLfloat blue, register __fp3 GLfloat alpha )
  338. {
  339.    GET_CONTEXT;
  340.    (*CC->API.Color4f)( CC, red, green, blue, alpha );
  341. }
  342.  
  343. __asm __saveds void APIENTRY glColor4i( register __d0 GLint red, register __d1 GLint green, register __d2 GLint blue, register __d3 GLint alpha )
  344. {
  345.    GET_CONTEXT;
  346.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(red), INT_TO_FLOAT(green),
  347.                        INT_TO_FLOAT(blue), INT_TO_FLOAT(alpha) );
  348. }
  349.  
  350.  
  351. __asm __saveds void APIENTRY glColor4s( register __d0 GLshort red, register __d1 GLshort green, register __d2 GLshort blue, register __d3 GLshort alpha )
  352. {
  353.    GET_CONTEXT;
  354.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(red), SHORT_TO_FLOAT(green),
  355.                        SHORT_TO_FLOAT(blue), SHORT_TO_FLOAT(alpha) );
  356. }
  357.  
  358. __asm __saveds void APIENTRY glColor4ub( register __d0 GLubyte red, register __d1 GLubyte green, register __d2 GLubyte blue, register __d3 GLubyte alpha )
  359. {
  360.    GET_CONTEXT;
  361.    (*CC->API.Color4ub)( CC, red, green, blue, alpha );
  362. }
  363.  
  364. __asm __saveds void APIENTRY glColor4ui( register __d0 GLuint red, register __d1 GLuint green, register __d2 GLuint blue, register __d3 GLuint alpha )
  365. {
  366.    GET_CONTEXT;
  367.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(red), UINT_TO_FLOAT(green),
  368.                        UINT_TO_FLOAT(blue), UINT_TO_FLOAT(alpha) );
  369. }
  370.  
  371. __asm __saveds void APIENTRY glColor4us( register __d0 GLushort red, register __d1 GLushort green, register __d2 GLushort blue, register __d3 GLushort alpha )
  372. {
  373.    GET_CONTEXT;
  374.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(red), USHORT_TO_FLOAT(green),
  375.                        USHORT_TO_FLOAT(blue), USHORT_TO_FLOAT(alpha) );
  376. }
  377.  
  378.  
  379. __asm __saveds void APIENTRY glColor3bv( register __a0 const GLbyte *v )
  380. {
  381.    GET_CONTEXT;
  382.    (*CC->API.Color3f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
  383.                        BYTE_TO_FLOAT(v[2]) );
  384. }
  385.  
  386.  
  387. __asm __saveds void APIENTRY glColor3dv( register __a0 const GLdouble *v )
  388. {
  389.    GET_CONTEXT;
  390.    (*CC->API.Color3f)( CC, (GLdouble) v[0], (GLdouble) v[1], (GLdouble) v[2] );
  391. }
  392.  
  393.  
  394. __asm __saveds void APIENTRY glColor3fv( register __a0 const GLfloat *v )
  395. {
  396.    GET_CONTEXT;
  397.    (*CC->API.Color3fv)( CC, v );
  398. }
  399.  
  400.  
  401. __asm __saveds void APIENTRY glColor3iv( register __a0 const GLint *v )
  402. {
  403.    GET_CONTEXT;
  404.    (*CC->API.Color3f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
  405.                        INT_TO_FLOAT(v[2]) );
  406. }
  407.  
  408.  
  409. __asm __saveds void APIENTRY glColor3sv( register __a0 const GLshort *v )
  410. {
  411.    GET_CONTEXT;
  412.    (*CC->API.Color3f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
  413.                        SHORT_TO_FLOAT(v[2]) );
  414. }
  415.  
  416.  
  417. __asm __saveds void APIENTRY glColor3ubv( register __a0 const GLubyte *v )
  418. {
  419.    GET_CONTEXT;
  420.    (*CC->API.Color4ub)( CC, v[0], v[1], v[2], 255 );
  421. }
  422.  
  423.  
  424. __asm __saveds void APIENTRY glColor3uiv( register __a0 const GLuint *v )
  425. {
  426.    GET_CONTEXT;
  427.    (*CC->API.Color3f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
  428.                        UINT_TO_FLOAT(v[2]) );
  429. }
  430.  
  431.  
  432. __asm __saveds void APIENTRY glColor3usv( register __a0 const GLushort *v )
  433. {
  434.    GET_CONTEXT;
  435.    (*CC->API.Color3f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
  436.                        USHORT_TO_FLOAT(v[2]) );
  437.  
  438. }
  439.  
  440.  
  441. __asm __saveds void APIENTRY glColor4bv( register __a0 const GLbyte *v )
  442. {
  443.    GET_CONTEXT;
  444.    (*CC->API.Color4f)( CC, BYTE_TO_FLOAT(v[0]), BYTE_TO_FLOAT(v[1]),
  445.                        BYTE_TO_FLOAT(v[2]), BYTE_TO_FLOAT(v[3]) );
  446. }
  447.  
  448.  
  449. __asm __saveds void APIENTRY glColor4dv( register __a0 const GLdouble *v )
  450. {
  451.    GET_CONTEXT;
  452.    (*CC->API.Color4f)( CC, (GLdouble) v[0], (GLdouble) v[1],
  453.                        (GLdouble) v[2], (GLdouble) v[3] );
  454. }
  455.  
  456.  
  457. __asm __saveds void APIENTRY glColor4fv( register __a0 const GLfloat *v )
  458. {
  459.    GET_CONTEXT;
  460.    (*CC->API.Color4f)( CC, v[0], v[1], v[2], v[3] );
  461. }
  462.  
  463.  
  464. __asm __saveds void APIENTRY glColor4iv( register __a0 const GLint *v )
  465. {
  466.    GET_CONTEXT;
  467.    (*CC->API.Color4f)( CC, INT_TO_FLOAT(v[0]), INT_TO_FLOAT(v[1]),
  468.                        INT_TO_FLOAT(v[2]), INT_TO_FLOAT(v[3]) );
  469. }
  470.  
  471.  
  472. __asm __saveds void APIENTRY glColor4sv( register __a0 const GLshort *v )
  473. {
  474.    GET_CONTEXT;
  475.    (*CC->API.Color4f)( CC, SHORT_TO_FLOAT(v[0]), SHORT_TO_FLOAT(v[1]),
  476.                        SHORT_TO_FLOAT(v[2]), SHORT_TO_FLOAT(v[3]) );
  477. }
  478.  
  479.  
  480. __asm __saveds void APIENTRY glColor4ubv( register __a0 const GLubyte *v )
  481. {
  482.    GET_CONTEXT;
  483.    (*CC->API.Color4ubv)( CC, v );
  484. }
  485.  
  486.  
  487. __asm __saveds void APIENTRY glColor4uiv( register __a0 const GLuint *v )
  488. {
  489.    GET_CONTEXT;
  490.    (*CC->API.Color4f)( CC, UINT_TO_FLOAT(v[0]), UINT_TO_FLOAT(v[1]),
  491.                        UINT_TO_FLOAT(v[2]), UINT_TO_FLOAT(v[3]) );
  492. }
  493.  
  494.  
  495. __asm __saveds void APIENTRY glColor4usv( register __a0 const GLushort *v )
  496. {
  497.    GET_CONTEXT;
  498.    (*CC->API.Color4f)( CC, USHORT_TO_FLOAT(v[0]), USHORT_TO_FLOAT(v[1]),
  499.                        USHORT_TO_FLOAT(v[2]), USHORT_TO_FLOAT(v[3]) );
  500. }
  501.  
  502.  
  503. __asm __saveds void APIENTRY glColorMask( register __d0 GLboolean red, register __d1 GLboolean green,
  504.                                           register __d2 GLboolean blue, register __d3 GLboolean alpha )
  505. {
  506.    GET_CONTEXT;
  507.    CHECK_CONTEXT;
  508.    (*CC->API.ColorMask)(CC, red, green, blue, alpha);
  509. }
  510.  
  511.  
  512. __asm __saveds void APIENTRY glColorMaterial( register __d0 GLenum face, register __d1 GLenum mode )
  513. {
  514.    GET_CONTEXT;
  515.    CHECK_CONTEXT;
  516.    (*CC->API.ColorMaterial)(CC, face, mode);
  517. }
  518.  
  519.  
  520. __asm __saveds void APIENTRY glColorPointer( register __d0 GLint size, register __d1 GLenum type, register __d2 GLsizei stride,
  521.                                              register __a0 const GLvoid *ptr )
  522. {
  523.    GET_CONTEXT;
  524.    CHECK_CONTEXT;
  525.    (*CC->API.ColorPointer)(CC, size, type, stride, ptr);
  526. }
  527.  
  528.  
  529. __asm __saveds void APIENTRY glColorTableEXT( register __d0 GLenum target, register __d1 GLenum internalFormat,
  530.                                               register __d2 GLsizei width, register __d3 GLenum format, register __d4 GLenum type,
  531.                                               register __a0 const GLvoid *table )
  532. {
  533.    struct gl_image *image;
  534.    GET_CONTEXT;
  535.    CHECK_CONTEXT;
  536.    image = gl_unpack_image( CC, width, 1, format, type, table );
  537.    (*CC->API.ColorTable)( CC, target, internalFormat, image );
  538.    if (image->RefCount == 0)
  539.       gl_free_image(image);
  540. }
  541.  
  542.  
  543. __asm __saveds void APIENTRY glColorSubTableEXT( register __d0 GLenum target, register __d1 GLsizei start, register __d2 GLsizei count,
  544.                                                  register __d3 GLenum format, register __d4 GLenum type,
  545.                                                  register __a0 const GLvoid *data )
  546. {
  547.    struct gl_image *image;
  548.    GET_CONTEXT;
  549.    CHECK_CONTEXT;
  550.    image = gl_unpack_image( CC, count, 1, format, type, data );
  551.    (*CC->API.ColorSubTable)( CC, target, start, image );
  552.    if (image->RefCount == 0)
  553.       gl_free_image(image);
  554. }
  555.  
  556.  
  557.  
  558. __asm __saveds void APIENTRY glCopyPixels( register __d0 GLint x, register __d1 GLint y, register __d2 GLsizei width, register __d3 GLsizei height,
  559.                                            register __d4 GLenum type )
  560. {
  561.    GET_CONTEXT;
  562.    CHECK_CONTEXT;
  563.    (*CC->API.CopyPixels)(CC, x, y, width, height, type);
  564. }
  565.  
  566.  
  567. __asm __saveds void APIENTRY glCopyTexImage1D( register __d0 GLenum target, register __d1 GLint level,
  568.                                                register __d2 GLenum internalformat,
  569.                                                register __d3 GLint x, register __d4 GLint y,
  570.                                                register __d5 GLsizei width, register __d6 GLint border )
  571. {
  572.    GET_CONTEXT;
  573.    CHECK_CONTEXT;
  574.    (*CC->API.CopyTexImage1D)( CC, target, level, internalformat,
  575.                                  x, y, width, border );
  576. }
  577.  
  578.  
  579. __asm __saveds void APIENTRY glCopyTexImage2D( register __d0 GLenum target, register __d1 GLint level,
  580.                                                register __d2 GLenum internalformat,
  581.                                                register __d3 GLint x, register __d4 GLint y,
  582.                                                register __d5 GLsizei width, register __d6 GLsizei height, register __d7 GLint border )
  583. {
  584.    GET_CONTEXT;
  585.    CHECK_CONTEXT;
  586.    (*CC->API.CopyTexImage2D)( CC, target, level, internalformat,
  587.                               x, y, width, height, border );
  588. }
  589.  
  590.  
  591. __asm __saveds void APIENTRY glCopyTexSubImage1D( register __d0 GLenum target, register __d1 GLint level,
  592.                                                   register __d2 GLint xoffset, register __d3 GLint x, register __d4 GLint y,
  593.                                                   register __d5 GLsizei width )
  594. {
  595.    GET_CONTEXT;
  596.    CHECK_CONTEXT;
  597.    (*CC->API.CopyTexSubImage1D)( CC, target, level, xoffset, x, y, width );
  598. }
  599.  
  600.  
  601. __asm __saveds void APIENTRY glCopyTexSubImage2D( register __d0 GLenum target, register __d1 GLint level,
  602.                                                   register __d2 GLint xoffset, register __d3 GLint yoffset,
  603.                                                   register __d4 GLint x, register __d5 GLint y,
  604.                                                   register __d6 GLsizei width, register __d7 GLsizei height )
  605. {
  606.    GET_CONTEXT;
  607.    CHECK_CONTEXT;
  608.    (*CC->API.CopyTexSubImage2D)( CC, target, level, xoffset, yoffset,
  609.                                  x, y, width, height );
  610. }
  611.  
  612.  
  613.  
  614. __asm __saveds void APIENTRY glCullFace( register __d0 GLenum mode )
  615. {
  616.    GET_CONTEXT;
  617.    CHECK_CONTEXT;
  618.    (*CC->API.CullFace)(CC, mode);
  619. }
  620.  
  621.  
  622. __asm __saveds void APIENTRY glDepthFunc( register __d0 GLenum func )
  623. {
  624.    GET_CONTEXT;
  625.    CHECK_CONTEXT;
  626.    (*CC->API.DepthFunc)( CC, func );
  627. }
  628.  
  629.  
  630. __asm __saveds void APIENTRY glDepthMask( register __d0 GLboolean flag )
  631. {
  632.    GET_CONTEXT;
  633.    CHECK_CONTEXT;
  634.    (*CC->API.DepthMask)( CC, flag );
  635. }
  636.  
  637.  
  638. __asm __saveds void APIENTRY glDepthRange( register __fp0 GLclampd near_val, register __fp1 GLclampd far_val )
  639. {
  640.    GET_CONTEXT;
  641.    CHECK_CONTEXT;
  642.    (*CC->API.DepthRange)( CC, near_val, far_val );
  643. }
  644.  
  645.  
  646. __asm __saveds void APIENTRY glDeleteLists( register __d0 GLuint list, register __d1 GLsizei range )
  647. {
  648.    GET_CONTEXT;
  649.    CHECK_CONTEXT;
  650.    (*CC->API.DeleteLists)(CC, list, range);
  651. }
  652.  
  653.  
  654. __asm __saveds void APIENTRY glDeleteTextures( register __d0 GLsizei n, register __a0 const GLuint *textures )
  655. {
  656.    GET_CONTEXT;
  657.    CHECK_CONTEXT;
  658.    (*CC->API.DeleteTextures)(CC, n, textures);
  659. }
  660.  
  661.  
  662. __asm __saveds void APIENTRY glDisable( register __d0 GLenum cap )
  663. {
  664.    GET_CONTEXT;
  665.    CHECK_CONTEXT;
  666.    (*CC->API.Disable)( CC, cap );
  667. }
  668.  
  669.  
  670. __asm __saveds void APIENTRY glDisableClientState( register __d0 GLenum cap )
  671. {
  672.    GET_CONTEXT;
  673.    CHECK_CONTEXT;
  674.    (*CC->API.DisableClientState)( CC, cap );
  675. }
  676.  
  677.  
  678. __asm __saveds void APIENTRY glDrawArrays( register __d0 GLenum mode, register __d1 GLint first, register __d2 GLsizei count )
  679. {
  680.    GET_CONTEXT;
  681.    CHECK_CONTEXT;
  682.    (*CC->API.DrawArrays)(CC, mode, first, count);
  683. }
  684.  
  685.  
  686. __asm __saveds void APIENTRY glDrawBuffer( register __d0 GLenum mode )
  687. {
  688.    GET_CONTEXT;
  689.    CHECK_CONTEXT;
  690.    (*CC->API.DrawBuffer)(CC, mode);
  691. }
  692.  
  693.  
  694. __asm __saveds void APIENTRY glDrawElements( register __d0 GLenum mode, register __d1 GLsizei count,
  695.                                              register __d2 GLenum type, register __a0 const GLvoid *indices )
  696. {
  697.    GET_CONTEXT;
  698.    CHECK_CONTEXT;
  699.    (*CC->API.DrawElements)( CC, mode, count, type, indices );
  700. }
  701.  
  702.  
  703. __asm __saveds void APIENTRY glDrawPixels( register __d0 GLsizei width, register __d1 GLsizei height,
  704.                                            register __d2 GLenum format, register __d3 GLenum type, register __a0 const GLvoid *pixels )
  705. {
  706.    GET_CONTEXT;
  707.    CHECK_CONTEXT;
  708.    (*CC->API.DrawPixels)( CC, width, height, format, type, pixels );
  709. }
  710.  
  711.  
  712. __asm __saveds void APIENTRY glEnable( register __d0 GLenum cap )
  713. {
  714.    GET_CONTEXT;
  715.    CHECK_CONTEXT;
  716.    (*CC->API.Enable)( CC, cap );
  717. }
  718.  
  719.  
  720. __asm __saveds void APIENTRY glEnableClientState( register __d0 GLenum cap )
  721. {
  722.    GET_CONTEXT;
  723.    CHECK_CONTEXT;
  724.    (*CC->API.EnableClientState)( CC, cap );
  725. }
  726.  
  727.  
  728. __asm __saveds void APIENTRY glEnd( void )
  729. {
  730.    GET_CONTEXT;
  731.    CHECK_CONTEXT;
  732.    (*CC->API.End)( CC );
  733. }
  734.  
  735.  
  736. __asm __saveds void APIENTRY glEndList( void )
  737. {
  738.    GET_CONTEXT;
  739.    CHECK_CONTEXT;
  740.    (*CC->API.EndList)(CC);
  741. }
  742.  
  743.  
  744.  
  745.  
  746. __asm __saveds void APIENTRY glEvalCoord1d( register __fp0 GLdouble u )
  747. {
  748.    GET_CONTEXT;
  749.    CHECK_CONTEXT;
  750.    (*CC->API.EvalCoord1f)( CC, (GLfloat) u );
  751. }
  752.  
  753.  
  754. __asm __saveds void APIENTRY glEvalCoord1f( register __fp0 GLfloat u )
  755. {
  756.    GET_CONTEXT;
  757.    CHECK_CONTEXT;
  758.    (*CC->API.EvalCoord1f)( CC, u );
  759. }
  760.  
  761.  
  762. __asm __saveds void APIENTRY glEvalCoord1dv( register __a0 const GLdouble *u )
  763. {
  764.    GET_CONTEXT;
  765.    CHECK_CONTEXT;
  766.    (*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
  767. }
  768.  
  769.  
  770. __asm __saveds void APIENTRY glEvalCoord1fv( register __a0 const GLfloat *u )
  771. {
  772.    GET_CONTEXT;
  773.    CHECK_CONTEXT;
  774.    (*CC->API.EvalCoord1f)( CC, (GLfloat) *u );
  775. }
  776.  
  777.  
  778. __asm __saveds void APIENTRY glEvalCoord2d( register __fp0 GLdouble u, register __fp1 GLdouble v )
  779. {
  780.    GET_CONTEXT;
  781.    CHECK_CONTEXT;
  782.    (*CC->API.EvalCoord2f)( CC, (GLfloat) u, (GLfloat) v );
  783. }
  784.  
  785.  
  786. __asm __saveds void APIENTRY glEvalCoord2f( register __fp0 GLfloat u, register __fp1 GLfloat v )
  787. {
  788.    GET_CONTEXT;
  789.    CHECK_CONTEXT;
  790.    (*CC->API.EvalCoord2f)( CC, u, v );
  791. }
  792.  
  793.  
  794. __asm __saveds void APIENTRY glEvalCoord2dv( register __a0 const GLdouble *u )
  795. {
  796.    GET_CONTEXT;
  797.    CHECK_CONTEXT;
  798.    (*CC->API.EvalCoord2f)( CC, (GLfloat) u[0], (GLfloat) u[1] );
  799. }
  800.  
  801.  
  802. __asm __saveds void APIENTRY glEvalCoord2fv( register __a0 const GLfloat *u )
  803. {
  804.    GET_CONTEXT;
  805.    CHECK_CONTEXT;
  806.    (*CC->API.EvalCoord2f)( CC, u[0], u[1] );
  807. }
  808.  
  809.  
  810. __asm __saveds void APIENTRY glEvalPoint1( register __d0 GLint i )
  811. {
  812.    GET_CONTEXT;
  813.    CHECK_CONTEXT;
  814.    (*CC->API.EvalPoint1)( CC, i );
  815. }
  816.  
  817.  
  818. __asm __saveds void APIENTRY glEvalPoint2( register __d0 GLint i, register __d1 GLint j )
  819. {
  820.    GET_CONTEXT;
  821.    CHECK_CONTEXT;
  822.    (*CC->API.EvalPoint2)( CC, i, j );
  823. }
  824.  
  825.  
  826. __asm __saveds void APIENTRY glEvalMesh1( register __d0 GLenum mode, register __d1 GLint i1, register __d2 GLint i2 )
  827. {
  828.    GET_CONTEXT;
  829.    CHECK_CONTEXT;
  830.    (*CC->API.EvalMesh1)( CC, mode, i1, i2 );
  831. }
  832.  
  833.  
  834. __asm __saveds void APIENTRY glEdgeFlag( register __d0 GLboolean flag )
  835. {
  836.    GET_CONTEXT;
  837.    CHECK_CONTEXT;
  838.    (*CC->API.EdgeFlag)(CC, flag);
  839. }
  840.  
  841.  
  842. __asm __saveds void APIENTRY glEdgeFlagv( register __a0 const GLboolean *flag )
  843. {
  844.    GET_CONTEXT;
  845.    CHECK_CONTEXT;
  846.    (*CC->API.EdgeFlag)(CC, *flag);
  847. }
  848.  
  849.  
  850. __asm __saveds void APIENTRY glEdgeFlagPointer( register __d0 GLsizei stride, register __a0 const GLboolean *ptr )
  851. {
  852.    GET_CONTEXT;
  853.    CHECK_CONTEXT;
  854.    (*CC->API.EdgeFlagPointer)(CC, stride, ptr);
  855. }
  856.  
  857.  
  858. __asm __saveds void APIENTRY glEvalMesh2( register __d0 GLenum mode, register __d1 GLint i1, register __d2 GLint i2, register __d3 GLint j1, register __d4 GLint j2 )
  859. {
  860.    GET_CONTEXT;
  861.    CHECK_CONTEXT;
  862.    (*CC->API.EvalMesh2)( CC, mode, i1, i2, j1, j2 );
  863. }
  864.  
  865.  
  866. __asm __saveds void APIENTRY glFeedbackBuffer( register __d0 GLsizei size, register __d1 GLenum type, register __a0 GLfloat *buffer )
  867. {
  868.    GET_CONTEXT;
  869.    CHECK_CONTEXT;
  870.    (*CC->API.FeedbackBuffer)(CC, size, type, buffer);
  871. }
  872.  
  873.  
  874. __asm __saveds void APIENTRY glFinish( void )
  875. {
  876.    GET_CONTEXT;
  877.    CHECK_CONTEXT;
  878.    (*CC->API.Finish)(CC);
  879. }
  880.  
  881.  
  882. __asm __saveds void APIENTRY glFlush( void )
  883. {
  884.    GET_CONTEXT;
  885.    CHECK_CONTEXT;
  886.    (*CC->API.Flush)(CC);
  887. }
  888.  
  889.  
  890. __asm __saveds void APIENTRY glFogf( register __d0 GLenum pname, register __fp0 GLfloat param )
  891. {
  892.    GLfloat f = param;
  893.    GET_CONTEXT;
  894.    CHECK_CONTEXT;
  895.    (*CC->API.Fogfv)(CC, pname, &f);
  896. }
  897.  
  898.  
  899. __asm __saveds void APIENTRY glFogi( register __d0 GLenum pname, register __d1 GLint param )
  900. {
  901.    GLfloat fparam = (GLfloat) param;
  902.    GET_CONTEXT;
  903.    CHECK_CONTEXT;
  904.    (*CC->API.Fogfv)(CC, pname, &fparam);
  905. }
  906.  
  907.  
  908. __asm __saveds void APIENTRY glFogfv( register __d0 GLenum pname, register __a0 const GLfloat *params )
  909. {
  910.    GET_CONTEXT;
  911.    CHECK_CONTEXT;
  912.    (*CC->API.Fogfv)(CC, pname, params);
  913. }
  914.  
  915.  
  916. __asm __saveds void APIENTRY glFogiv( register __d0 GLenum pname, register __a0 const GLint *params )
  917. {
  918.    GLfloat p[4];
  919.    GET_CONTEXT;
  920.    CHECK_CONTEXT;
  921.  
  922.    switch (pname) {
  923.       case GL_FOG_MODE:
  924.       case GL_FOG_DENSITY:
  925.       case GL_FOG_START:
  926.       case GL_FOG_END:
  927.       case GL_FOG_INDEX:
  928.      p[0] = (GLfloat) *params;
  929.      break;
  930.       case GL_FOG_COLOR:
  931.      p[0] = INT_TO_FLOAT( params[0] );
  932.      p[1] = INT_TO_FLOAT( params[1] );
  933.      p[2] = INT_TO_FLOAT( params[2] );
  934.      p[3] = INT_TO_FLOAT( params[3] );
  935.      break;
  936.       default:
  937.          /* Error will be caught later in gl_Fogfv */
  938.          ;
  939.    }
  940.    (*CC->API.Fogfv)( CC, pname, p );
  941. }
  942.  
  943.  
  944.  
  945. __asm __saveds void APIENTRY glFrontFace( register __d0 GLenum mode )
  946. {
  947.    GET_CONTEXT;
  948.    CHECK_CONTEXT;
  949.    (*CC->API.FrontFace)(CC, mode);
  950. }
  951.  
  952.  
  953. __asm __saveds void APIENTRY glFrustumA(register __a0 void *vargs)
  954. {
  955.     struct glFrustumArgs {
  956.         GLdouble left;
  957.         GLdouble right;
  958.         GLdouble bottom;
  959.         GLdouble top;
  960.         GLdouble nearval;
  961.         GLdouble farval;
  962.     } *args;
  963.  
  964.     args = (struct glFrustumArgs *)vargs;
  965.  
  966.     glFrustum(args->left, args->right, args->bottom, args->top, args->nearval, args->farval);
  967. }
  968.  
  969.  
  970. __asm __saveds void APIENTRY glFrustum( register __fp0 GLdouble left, register __fp1 GLdouble right,
  971.                                         register __fp2 GLdouble bottom, register __fp3 GLdouble top,
  972.                                         register __fp4 GLdouble nearval, register __fp5 GLdouble farval )
  973. {
  974.    GET_CONTEXT;
  975.    CHECK_CONTEXT;
  976.    (*CC->API.Frustum)(CC, left, right, bottom, top, nearval, farval);
  977. }
  978.  
  979.  
  980. __asm __saveds GLuint APIENTRY glGenLists( register __d0 GLsizei range )
  981. {
  982.    GET_CONTEXT;
  983.    CHECK_CONTEXT_RETURN(0);
  984.    return (*CC->API.GenLists)(CC, range);
  985. }
  986.  
  987.  
  988. __asm __saveds void APIENTRY glGenTextures( register __d0 GLsizei n, register __a0 GLuint *textures )
  989. {
  990.    GET_CONTEXT;
  991.    CHECK_CONTEXT;
  992.    (*CC->API.GenTextures)(CC, n, textures);
  993. }
  994.  
  995.  
  996. __asm __saveds void APIENTRY glGetBooleanv( register __d0 GLenum pname, register __a0 GLboolean *params )
  997. {
  998.    GET_CONTEXT;
  999.    CHECK_CONTEXT;
  1000.    (*CC->API.GetBooleanv)(CC, pname, params);
  1001. }
  1002.  
  1003.  
  1004. __asm __saveds void APIENTRY glGetClipPlane( register __d0 GLenum plane, register __a0 GLdouble *equation )
  1005. {
  1006.    GET_CONTEXT;
  1007.    CHECK_CONTEXT;
  1008.    (*CC->API.GetClipPlane)(CC, plane, equation);
  1009. }
  1010.  
  1011.  
  1012. __asm __saveds void APIENTRY glGetColorTableEXT( register __d0 GLenum target, register __d1 GLenum format,
  1013.                                                  register __d2 GLenum type, register __a0 GLvoid *table )
  1014. {
  1015.    GET_CONTEXT;
  1016.    CHECK_CONTEXT;
  1017.    (*CC->API.GetColorTable)(CC, target, format, type, table);
  1018. }
  1019.  
  1020.  
  1021. __asm __saveds void APIENTRY glGetColorTableParameterivEXT( register __d0 GLenum target, register __d1 GLenum pname,
  1022.                                                             register __a0 GLint *params )
  1023. {
  1024.    GET_CONTEXT;
  1025.    CHECK_CONTEXT;
  1026.    (*CC->API.GetColorTableParameteriv)(CC, target, pname, params);
  1027. }
  1028.  
  1029.  
  1030. __asm __saveds void APIENTRY glGetColorTableParameterfvEXT( register __d0 GLenum target, register __d1 GLenum pname,
  1031.                                                             register __a0 GLfloat *params )
  1032. {
  1033.    GLint iparams;
  1034.    glGetColorTableParameterivEXT( target, pname, &iparams );
  1035.    *params = (GLfloat) iparams;
  1036. }
  1037.  
  1038.  
  1039. __asm __saveds void APIENTRY glGetDoublev( register __d0 GLenum pname, register __a0 GLdouble *params )
  1040. {
  1041.    GET_CONTEXT;
  1042.    CHECK_CONTEXT;
  1043.    (*CC->API.GetDoublev)(CC, pname, params);
  1044. }
  1045.  
  1046.  
  1047. __asm __saveds GLenum APIENTRY glGetError( void )
  1048. {
  1049.    GET_CONTEXT;
  1050.    if (!CC) {
  1051.       /* No current context */
  1052.       return GL_NO_ERROR;
  1053.    }
  1054.    return (*CC->API.GetError)(CC);
  1055. }
  1056.  
  1057.  
  1058. __asm __saveds void APIENTRY glGetFloatv( register __d0 GLenum pname, register __a0 GLfloat *params )
  1059. {
  1060.    GET_CONTEXT;
  1061.    CHECK_CONTEXT;
  1062.    (*CC->API.GetFloatv)(CC, pname, params);
  1063. }
  1064.  
  1065.  
  1066. __asm __saveds void APIENTRY glGetIntegerv( register __d0 GLenum pname, register __a0 GLint *params )
  1067. {
  1068.    GET_CONTEXT;
  1069.    CHECK_CONTEXT;
  1070.    (*CC->API.GetIntegerv)(CC, pname, params);
  1071. }
  1072.  
  1073.  
  1074. __asm __saveds void APIENTRY glGetLightfv( register __d0 GLenum light, register __d1 GLenum pname, register __a0 GLfloat *params )
  1075. {
  1076.    GET_CONTEXT;
  1077.    CHECK_CONTEXT;
  1078.    (*CC->API.GetLightfv)(CC, light, pname, params);
  1079. }
  1080.  
  1081.  
  1082. __asm __saveds void APIENTRY glGetLightiv( register __d0 GLenum light, register __d1 GLenum pname, register __a0 GLint *params )
  1083. {
  1084.    GET_CONTEXT;
  1085.    CHECK_CONTEXT;
  1086.    (*CC->API.GetLightiv)(CC, light, pname, params);
  1087. }
  1088.  
  1089.  
  1090. __asm __saveds void APIENTRY glGetMapdv( register __d0 GLenum target, register __d1 GLenum query, register __a0 GLdouble *v )
  1091. {
  1092.    GET_CONTEXT;
  1093.    CHECK_CONTEXT;
  1094.    (*CC->API.GetMapdv)( CC, target, query, v );
  1095. }
  1096.  
  1097.  
  1098. __asm __saveds void APIENTRY glGetMapfv( register __d0 GLenum target, register __d1 GLenum query, register __a0 GLfloat *v )
  1099. {
  1100.    GET_CONTEXT;
  1101.    CHECK_CONTEXT;
  1102.    (*CC->API.GetMapfv)( CC, target, query, v );
  1103. }
  1104.  
  1105.  
  1106. __asm __saveds void APIENTRY glGetMapiv( register __d0 GLenum target, register __d1 GLenum query, register __a0 GLint *v )
  1107. {
  1108.    GET_CONTEXT;
  1109.    CHECK_CONTEXT;
  1110.    (*CC->API.GetMapiv)( CC, target, query, v );
  1111. }
  1112.  
  1113.  
  1114. __asm __saveds void APIENTRY glGetMaterialfv( register __d0 GLenum face, register __d1 GLenum pname, register __a0 GLfloat *params )
  1115. {
  1116.    GET_CONTEXT;
  1117.    CHECK_CONTEXT;
  1118.    (*CC->API.GetMaterialfv)(CC, face, pname, params);
  1119. }
  1120.  
  1121.  
  1122. __asm __saveds void APIENTRY glGetMaterialiv( register __d0 GLenum face, register __d1 GLenum pname, register __a0 GLint *params )
  1123. {
  1124.    GET_CONTEXT;
  1125.    CHECK_CONTEXT;
  1126.    (*CC->API.GetMaterialiv)(CC, face, pname, params);
  1127. }
  1128.  
  1129.  
  1130. __asm __saveds void APIENTRY glGetPixelMapfv( register __d0 GLenum map, register __a0 GLfloat *values )
  1131. {
  1132.    GET_CONTEXT;
  1133.    CHECK_CONTEXT;
  1134.    (*CC->API.GetPixelMapfv)(CC, map, values);
  1135. }
  1136.  
  1137.  
  1138. __asm __saveds void APIENTRY glGetPixelMapuiv( register __d0 GLenum map, register __a0 GLuint *values )
  1139. {
  1140.    GET_CONTEXT;
  1141.    CHECK_CONTEXT;
  1142.    (*CC->API.GetPixelMapuiv)(CC, map, values);
  1143. }
  1144.  
  1145.  
  1146. __asm __saveds void APIENTRY glGetPixelMapusv( register __d0 GLenum map, register __a0 GLushort *values )
  1147. {
  1148.    GET_CONTEXT;
  1149.    CHECK_CONTEXT;
  1150.    (*CC->API.GetPixelMapusv)(CC, map, values);
  1151. }
  1152.  
  1153.  
  1154. __asm __saveds void APIENTRY glGetPointerv( register __d0 GLenum pname, register __a0 GLvoid **params )
  1155. {
  1156.    GET_CONTEXT;
  1157.    CHECK_CONTEXT;
  1158.    (*CC->API.GetPointerv)(CC, pname, params);
  1159. }
  1160.  
  1161.  
  1162. __asm __saveds void APIENTRY glGetPolygonStipple( register __a0 GLubyte *mask )
  1163. {
  1164.    GET_CONTEXT;
  1165.    CHECK_CONTEXT;
  1166.    (*CC->API.GetPolygonStipple)(CC, mask);
  1167. }
  1168.  
  1169.  
  1170. __asm __saveds const GLubyte * APIENTRY glGetString( register __d0 GLenum name )
  1171. {
  1172.    GET_CONTEXT;
  1173.    CHECK_CONTEXT_RETURN(NULL);
  1174.    return (*CC->API.GetString)(CC, name);
  1175. }
  1176.  
  1177.  
  1178.  
  1179. __asm __saveds void APIENTRY glGetTexEnvfv( register __d0 GLenum target, register __d1 GLenum pname, register __a0 GLfloat *params )
  1180. {
  1181.    GET_CONTEXT;
  1182.    CHECK_CONTEXT;
  1183.    (*CC->API.GetTexEnvfv)(CC, target, pname, params);
  1184. }
  1185.  
  1186.  
  1187. __asm __saveds void APIENTRY glGetTexEnviv( register __d0 GLenum target, register __d1 GLenum pname, register __a0 GLint *params )
  1188. {
  1189.    GET_CONTEXT;
  1190.    CHECK_CONTEXT;
  1191.    (*CC->API.GetTexEnviv)(CC, target, pname, params);
  1192. }
  1193.  
  1194.  
  1195. __asm __saveds void APIENTRY glGetTexGeniv( register __d0 GLenum coord, register __d1 GLenum pname, register __a0 GLint *params )
  1196. {
  1197.    GET_CONTEXT;
  1198.    CHECK_CONTEXT;
  1199.    (*CC->API.GetTexGeniv)(CC, coord, pname, params);
  1200. }
  1201.  
  1202.  
  1203. __asm __saveds void APIENTRY glGetTexGendv( register __d0 GLenum coord, register __d1 GLenum pname, register __a0 GLdouble *params )
  1204. {
  1205.    GET_CONTEXT;
  1206.    CHECK_CONTEXT;
  1207.    (*CC->API.GetTexGendv)(CC, coord, pname, params);
  1208. }
  1209.  
  1210.  
  1211. __asm __saveds void APIENTRY glGetTexGenfv( register __d0 GLenum coord, register __d1 GLenum pname, register __a0 GLfloat *params )
  1212. {
  1213.    GET_CONTEXT;
  1214.    CHECK_CONTEXT;
  1215.    (*CC->API.GetTexGenfv)(CC, coord, pname, params);
  1216. }
  1217.  
  1218.  
  1219.  
  1220. __asm __saveds void APIENTRY glGetTexImage( register __d0 GLenum target, register __d1 GLint level, register __d2 GLenum format,
  1221.                                             register __d3 GLenum type, register __a0 GLvoid *pixels )
  1222. {
  1223.    GET_CONTEXT;
  1224.    CHECK_CONTEXT;
  1225.    (*CC->API.GetTexImage)(CC, target, level, format, type, pixels);
  1226. }
  1227.  
  1228.  
  1229. __asm __saveds void APIENTRY glGetTexLevelParameterfv( register __d0 GLenum target, register __d1 GLint level,
  1230.                                                        register __d2 GLenum pname, register __a0 GLfloat *params )
  1231. {
  1232.    GET_CONTEXT;
  1233.    CHECK_CONTEXT;
  1234.    (*CC->API.GetTexLevelParameterfv)(CC, target, level, pname, params);
  1235. }
  1236.  
  1237.  
  1238. __asm __saveds void APIENTRY glGetTexLevelParameteriv( register __d0 GLenum target, register __d1 GLint level,
  1239.                                                        register __d2 GLenum pname, register __a0 GLint *params )
  1240. {
  1241.    GET_CONTEXT;
  1242.    CHECK_CONTEXT;
  1243.    (*CC->API.GetTexLevelParameteriv)(CC, target, level, pname, params);
  1244. }
  1245.  
  1246.  
  1247.  
  1248.  
  1249. __asm __saveds void APIENTRY glGetTexParameterfv( register __d0 GLenum target, register __d1 GLenum pname, register __a0 GLfloat *params )
  1250. {
  1251.    GET_CONTEXT;
  1252.    CHECK_CONTEXT;
  1253.    (*CC->API.GetTexParameterfv)(CC, target, pname, params);
  1254. }
  1255.  
  1256.  
  1257. __asm __saveds void APIENTRY glGetTexParameteriv( register __d0 GLenum target, register __d1 GLenum pname, register __a0 GLint *params )
  1258. {
  1259.    GET_CONTEXT;
  1260.    CHECK_CONTEXT;
  1261.    (*CC->API.GetTexParameteriv)(CC, target, pname, params);
  1262. }
  1263.  
  1264.  
  1265. __asm __saveds void APIENTRY glHint( register __d0 GLenum target, register __d1 GLenum mode )
  1266. {
  1267.    GET_CONTEXT;
  1268.    CHECK_CONTEXT;
  1269.    (*CC->API.Hint)(CC, target, mode);
  1270. }
  1271.  
  1272.  
  1273. __asm __saveds void APIENTRY glIndexd( register __fp0 GLdouble c )
  1274. {
  1275.    GET_CONTEXT;
  1276.    (*CC->API.Indexf)( CC, (GLfloat) c );
  1277. }
  1278.  
  1279.  
  1280. __asm __saveds void APIENTRY glIndexf( register __fp0 GLfloat c )
  1281. {
  1282.    GET_CONTEXT;
  1283.    (*CC->API.Indexf)( CC, c );
  1284. }
  1285.  
  1286.  
  1287. __asm __saveds void APIENTRY glIndexi( register __d0 GLint c )
  1288. {
  1289.    GET_CONTEXT;
  1290.    (*CC->API.Indexi)( CC, c );
  1291. }
  1292.  
  1293.  
  1294. __asm __saveds void APIENTRY glIndexs( register __d0 GLshort c )
  1295. {
  1296.    GET_CONTEXT;
  1297.    (*CC->API.Indexi)( CC, (GLint) c );
  1298. }
  1299.  
  1300.  
  1301. #ifdef GL_VERSION_1_1
  1302. __asm __saveds void APIENTRY glIndexub( register __d0 GLubyte c )
  1303. {
  1304.    GET_CONTEXT;
  1305.    (*CC->API.Indexi)( CC, (GLint) c );
  1306. }
  1307. #endif
  1308.  
  1309.  
  1310. __asm __saveds void APIENTRY glIndexdv( register __a0 const GLdouble *c )
  1311. {
  1312.    GET_CONTEXT;
  1313.    (*CC->API.Indexf)( CC, (GLfloat) *c );
  1314. }
  1315.  
  1316.  
  1317. __asm __saveds void APIENTRY glIndexfv( register __a0 const GLfloat *c )
  1318. {
  1319.    GET_CONTEXT;
  1320.    (*CC->API.Indexf)( CC, *c );
  1321. }
  1322.  
  1323.  
  1324. __asm __saveds void APIENTRY glIndexiv( register __a0 const GLint *c )
  1325. {
  1326.    GET_CONTEXT;
  1327.    (*CC->API.Indexi)( CC, *c );
  1328. }
  1329.  
  1330.  
  1331. __asm __saveds void APIENTRY glIndexsv( register __a0 const GLshort *c )
  1332. {
  1333.    GET_CONTEXT;
  1334.    (*CC->API.Indexi)( CC, (GLint) *c );
  1335. }
  1336.  
  1337.  
  1338. #ifdef GL_VERSION_1_1
  1339. __asm __saveds void APIENTRY glIndexubv( register __a0 const GLubyte *c )
  1340. {
  1341.    GET_CONTEXT;
  1342.    (*CC->API.Indexi)( CC, (GLint) *c );
  1343. }
  1344. #endif
  1345.  
  1346.  
  1347. __asm __saveds void APIENTRY glIndexMask( register __d0 GLuint mask )
  1348. {
  1349.    GET_CONTEXT;
  1350.    (*CC->API.IndexMask)(CC, mask);
  1351. }
  1352.  
  1353.  
  1354. __asm __saveds void APIENTRY glIndexPointer( register __d0 GLenum type, register __d1 GLsizei stride, register __a0 const GLvoid *ptr )
  1355. {
  1356.    GET_CONTEXT;
  1357.    CHECK_CONTEXT;
  1358.    (*CC->API.IndexPointer)(CC, type, stride, ptr);
  1359. }
  1360.  
  1361.  
  1362. __asm __saveds void APIENTRY glInterleavedArrays( register __d0 GLenum format, register __d1 GLsizei stride,
  1363.                                                   register __a0 const GLvoid *pointer )
  1364. {
  1365.    GET_CONTEXT;
  1366.    CHECK_CONTEXT;
  1367.    (*CC->API.InterleavedArrays)( CC, format, stride, pointer );
  1368. }
  1369.  
  1370.  
  1371. __asm __saveds void APIENTRY glInitNames( void )
  1372. {
  1373.    GET_CONTEXT;
  1374.    CHECK_CONTEXT;
  1375.    (*CC->API.InitNames)(CC);
  1376. }
  1377.  
  1378.  
  1379. __asm __saveds GLboolean APIENTRY glIsList( register __d0 GLuint list )
  1380. {
  1381.    GET_CONTEXT;
  1382.    CHECK_CONTEXT_RETURN(GL_FALSE);
  1383.    return (*CC->API.IsList)(CC, list);
  1384. }
  1385.  
  1386.  
  1387. __asm __saveds GLboolean APIENTRY glIsTexture( register __d0 GLuint texture )
  1388. {
  1389.    GET_CONTEXT;
  1390.    CHECK_CONTEXT_RETURN(GL_FALSE);
  1391.    return (*CC->API.IsTexture)(CC, texture);
  1392. }
  1393.  
  1394.  
  1395. __asm __saveds void APIENTRY glLightf( register __d0 GLenum light, register __d1 GLenum pname, register __fp0 GLfloat param )
  1396. {
  1397.    GLfloat f = param;
  1398.  
  1399.    GET_CONTEXT;
  1400.    CHECK_CONTEXT;
  1401.    (*CC->API.Lightfv)( CC, light, pname, &f, 1 );
  1402. }
  1403.  
  1404.  
  1405.  
  1406. __asm __saveds void APIENTRY glLighti( register __d0 GLenum light, register __d1 GLenum pname, register __d2 GLint param )
  1407. {
  1408.    GLfloat fparam = (GLfloat) param;
  1409.    GET_CONTEXT;
  1410.    CHECK_CONTEXT;
  1411.    (*CC->API.Lightfv)( CC, light, pname, &fparam, 1 );
  1412. }
  1413.  
  1414.  
  1415.  
  1416. __asm __saveds void APIENTRY glLightfv( register __d0 GLenum light, register __d1 GLenum pname, register __a0 const GLfloat *params )
  1417. {
  1418.    GET_CONTEXT;
  1419.    CHECK_CONTEXT;
  1420.    (*CC->API.Lightfv)( CC, light, pname, params, 4 );
  1421. }
  1422.  
  1423.  
  1424.  
  1425. __asm __saveds void APIENTRY glLightiv( register __d0 GLenum light, register __d1 GLenum pname, register __a0 const GLint *params )
  1426. {
  1427.    GLfloat fparam[4];
  1428.    GET_CONTEXT;
  1429.    CHECK_CONTEXT;
  1430.  
  1431.    switch (pname) {
  1432.       case GL_AMBIENT:
  1433.       case GL_DIFFUSE:
  1434.       case GL_SPECULAR:
  1435.          fparam[0] = INT_TO_FLOAT( params[0] );
  1436.          fparam[1] = INT_TO_FLOAT( params[1] );
  1437.          fparam[2] = INT_TO_FLOAT( params[2] );
  1438.          fparam[3] = INT_TO_FLOAT( params[3] );
  1439.          break;
  1440.       case GL_POSITION:
  1441.          fparam[0] = (GLfloat) params[0];
  1442.          fparam[1] = (GLfloat) params[1];
  1443.          fparam[2] = (GLfloat) params[2];
  1444.          fparam[3] = (GLfloat) params[3];
  1445.          break;
  1446.       case GL_SPOT_DIRECTION:
  1447.          fparam[0] = (GLfloat) params[0];
  1448.          fparam[1] = (GLfloat) params[1];
  1449.          fparam[2] = (GLfloat) params[2];
  1450.          break;
  1451.       case GL_SPOT_EXPONENT:
  1452.       case GL_SPOT_CUTOFF:
  1453.       case GL_CONSTANT_ATTENUATION:
  1454.       case GL_LINEAR_ATTENUATION:
  1455.       case GL_QUADRATIC_ATTENUATION:
  1456.          fparam[0] = (GLfloat) params[0];
  1457.          break;
  1458.       default:
  1459.          /* error will be caught later in gl_Lightfv */
  1460.          ;
  1461.    }
  1462.    (*CC->API.Lightfv)( CC, light, pname, fparam, 4 );
  1463. }
  1464.  
  1465.  
  1466.  
  1467. __asm __saveds void APIENTRY glLightModelf( register __d0 GLenum pname, register __fp0 GLfloat param )
  1468. {
  1469.    GLfloat f = param;
  1470.  
  1471.    GET_CONTEXT;
  1472.    CHECK_CONTEXT;
  1473.    (*CC->API.LightModelfv)( CC, pname, &f );
  1474. }
  1475.  
  1476.  
  1477. __asm __saveds void APIENTRY glLightModeli( register __d0 GLenum pname, register __d1 GLint param )
  1478. {
  1479.    GLfloat fparam[4];
  1480.    GET_CONTEXT;
  1481.    CHECK_CONTEXT;
  1482.    fparam[0] = (GLfloat) param;
  1483.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1484. }
  1485.  
  1486.  
  1487. __asm __saveds void APIENTRY glLightModelfv( register __d0 GLenum pname, register __a0 const GLfloat *params )
  1488. {
  1489.    GET_CONTEXT;
  1490.    CHECK_CONTEXT;
  1491.    (*CC->API.LightModelfv)( CC, pname, params );
  1492. }
  1493.  
  1494.  
  1495. __asm __saveds void APIENTRY glLightModeliv( register __d0 GLenum pname, register __a0 const GLint *params )
  1496. {
  1497.    GLfloat fparam[4];
  1498.    GET_CONTEXT;
  1499.    CHECK_CONTEXT;
  1500.  
  1501.    switch (pname) {
  1502.       case GL_LIGHT_MODEL_AMBIENT:
  1503.          fparam[0] = INT_TO_FLOAT( params[0] );
  1504.          fparam[1] = INT_TO_FLOAT( params[1] );
  1505.          fparam[2] = INT_TO_FLOAT( params[2] );
  1506.          fparam[3] = INT_TO_FLOAT( params[3] );
  1507.          break;
  1508.       case GL_LIGHT_MODEL_LOCAL_VIEWER:
  1509.       case GL_LIGHT_MODEL_TWO_SIDE:
  1510.          fparam[0] = (GLfloat) params[0];
  1511.          break;
  1512.       default:
  1513.          /* Error will be caught later in gl_LightModelfv */
  1514.          ;
  1515.    }
  1516.    (*CC->API.LightModelfv)( CC, pname, fparam );
  1517. }
  1518.  
  1519.  
  1520. __asm __saveds void APIENTRY glLineWidth( register __fp0 GLfloat width )
  1521. {
  1522.    GET_CONTEXT;
  1523.    CHECK_CONTEXT;
  1524.    (*CC->API.LineWidth)(CC, width);
  1525. }
  1526.  
  1527.  
  1528. __asm __saveds void APIENTRY glLineStipple( register __d0 GLint factor, register __d1 GLushort pattern )
  1529. {
  1530.    GET_CONTEXT;
  1531.    CHECK_CONTEXT;
  1532.    (*CC->API.LineStipple)(CC, factor, pattern);
  1533. }
  1534.  
  1535.  
  1536. __asm __saveds void APIENTRY glListBase( register __d0 GLuint base )
  1537. {
  1538.    GET_CONTEXT;
  1539.    CHECK_CONTEXT;
  1540.    (*CC->API.ListBase)(CC, base);
  1541. }
  1542.  
  1543.  
  1544. __asm __saveds void APIENTRY glLoadIdentity( void )
  1545. {
  1546.    GET_CONTEXT;
  1547.    CHECK_CONTEXT;
  1548.    (*CC->API.LoadIdentity)( CC );
  1549. }
  1550.  
  1551.  
  1552. __asm __saveds void APIENTRY glLoadMatrixd( register __a0 const GLdouble *m )
  1553. {
  1554.    GLfloat fm[16];
  1555.    GLuint i;
  1556.    GET_CONTEXT;
  1557.    CHECK_CONTEXT;
  1558.  
  1559.    for (i=0;i<16;i++) {
  1560.       fm[i] = (GLfloat) m[i];
  1561.    }
  1562.  
  1563.    (*CC->API.LoadMatrixf)( CC, fm );
  1564. }
  1565.  
  1566.  
  1567. __asm __saveds void APIENTRY glLoadMatrixf( register __a0 const GLfloat *m )
  1568. {
  1569.    GET_CONTEXT;
  1570.    CHECK_CONTEXT;
  1571.    (*CC->API.LoadMatrixf)( CC, m );
  1572. }
  1573.  
  1574.  
  1575. __asm __saveds void APIENTRY glLoadName( register __d0 GLuint name )
  1576. {
  1577.    GET_CONTEXT;
  1578.    CHECK_CONTEXT;
  1579.    (*CC->API.LoadName)(CC, name);
  1580. }
  1581.  
  1582.  
  1583. __asm __saveds void APIENTRY glLogicOp( register __d0 GLenum opcode )
  1584. {
  1585.    GET_CONTEXT;
  1586.    CHECK_CONTEXT;
  1587.    (*CC->API.LogicOp)(CC, opcode);
  1588. }
  1589.  
  1590.  
  1591.  
  1592. __asm __saveds void APIENTRY glMap1dA(register __a0 void *vargs)
  1593. {
  1594.     struct glMap1dArgs {
  1595.         GLenum target;
  1596.         GLdouble u1;
  1597.         GLdouble u2;
  1598.         GLint stride;
  1599.         GLint order;
  1600.         GLdouble *points;
  1601.     } *args;
  1602.  
  1603.     args = (struct glMap1dArgs *)vargs;
  1604.  
  1605.     glMap1d(args->target, args->u1, args->u2, args->stride, args->order, args->points);
  1606. }
  1607.  
  1608.  
  1609. __asm __saveds void APIENTRY glMap1d( register __d0 GLenum target, register __fp0 GLdouble u1, register __fp1 GLdouble u2, register __d1 GLint stride,
  1610.                                       register __d2 GLint order, register __a0 const GLdouble *points )
  1611. {
  1612.    GLfloat *pnts;
  1613.    GLboolean retain;
  1614.    GET_CONTEXT;
  1615.    CHECK_CONTEXT;
  1616.  
  1617.    pnts = gl_copy_map_points1d( target, stride, order, points );
  1618.    retain = CC->CompileFlag;
  1619.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1620. }
  1621.  
  1622.  
  1623. __asm __saveds void APIENTRY glMap1fA(register __a0 void *vargs)
  1624. {
  1625.     struct glMap1fArgs {
  1626.         GLenum target;
  1627.         GLfloat u1;
  1628.         GLfloat u2;
  1629.         GLint stride;
  1630.         GLint order;
  1631.         GLfloat *points;
  1632.     } *args;
  1633.  
  1634.     args = (struct glMap1fArgs *)vargs;
  1635.  
  1636.     glMap1f(args->target, args->u1, args->u2, args->stride, args->order, args->points);
  1637. }
  1638.  
  1639.  
  1640. __asm __saveds void APIENTRY glMap1f( register __d0 GLenum target, register __fp0 GLfloat u1, register __fp1 GLfloat u2, register __d1 GLint stride,
  1641.                                       register __d2 GLint order, register __a0 const GLfloat *points )
  1642. {
  1643.    GLfloat *pnts;
  1644.    GLboolean retain;
  1645.    GET_CONTEXT;
  1646.    CHECK_CONTEXT;
  1647.  
  1648.    pnts = gl_copy_map_points1f( target, stride, order, points );
  1649.    retain = CC->CompileFlag;
  1650.    (*CC->API.Map1f)( CC, target, u1, u2, stride, order, pnts, retain );
  1651. }
  1652.  
  1653.  
  1654. __asm __saveds void APIENTRY glMap2dA(register __a0 void *vargs)
  1655. {
  1656.     struct glMap2dArgs {
  1657.         GLenum target;
  1658.         GLdouble u1;
  1659.         GLdouble u2;
  1660.         GLint ustride;
  1661.         GLint uorder;
  1662.         GLdouble v1;
  1663.         GLdouble v2;
  1664.         GLint vstride;
  1665.         GLint vorder;
  1666.         GLdouble *points;
  1667.     } *args;
  1668.  
  1669.     args = (struct glMap2dArgs *)vargs;
  1670.  
  1671.     glMap2d(args->target, args->u1, args->u2, args->ustride, args->uorder, args->v1, args->v2, args->vstride, args->vorder, args->points);
  1672. }
  1673.  
  1674.  
  1675. __asm __saveds void APIENTRY glMap2d( register __d0 GLenum target,
  1676.                                       register __fp0 GLdouble u1, register __fp1 GLdouble u2, register __d1 GLint ustride, register __d2 GLint uorder,
  1677.                                       register __fp2 GLdouble v1, register __fp3 GLdouble v2, register __d3 GLint vstride, register __d4 GLint vorder,
  1678.                                       register __a0 const GLdouble *points )
  1679. {
  1680.    GLfloat *pnts;
  1681.    GLboolean retain;
  1682.    GET_CONTEXT;
  1683.    CHECK_CONTEXT;
  1684.  
  1685.    pnts = gl_copy_map_points2d( target, ustride, uorder,
  1686.                                 vstride, vorder, points );
  1687.    retain = CC->CompileFlag;
  1688.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1689.                      v1, v2, vstride, vorder, pnts, retain );
  1690. }
  1691.  
  1692.  
  1693. __asm __saveds void APIENTRY glMap2fA(register __a0 void *vargs)
  1694. {
  1695.     struct glMap2fArgs {
  1696.         GLenum target;
  1697.         GLfloat u1;
  1698.         GLfloat u2;
  1699.         GLint ustride;
  1700.         GLint uorder;
  1701.         GLfloat v1;
  1702.         GLfloat v2;
  1703.         GLint vstride;
  1704.         GLint vorder;
  1705.         GLfloat *points;
  1706.     } *args;
  1707.  
  1708.     args = (struct glMap2fArgs *)vargs;
  1709.  
  1710.     glMap2f(args->target, args->u1, args->u2, args->ustride, args->uorder, args->v1, args->v2, args->vstride, args->vorder, args->points);
  1711. }
  1712.  
  1713.  
  1714. __asm __saveds void APIENTRY glMap2f( register __d0 GLenum target,
  1715.                                       register __fp0 GLfloat u1, register __fp1 GLfloat u2, register __d1 GLint ustride, register __d2 GLint uorder,
  1716.                                       register __fp2 GLfloat v1, register __fp3 GLfloat v2, register __d3 GLint vstride, register __d4 GLint vorder,
  1717.                                       register __a0 const GLfloat *points )
  1718. {
  1719.    GLfloat *pnts;
  1720.    GLboolean retain;
  1721.    GET_CONTEXT;
  1722.    CHECK_CONTEXT;
  1723.  
  1724.    pnts = gl_copy_map_points2f( target, ustride, uorder,
  1725.                                 vstride, vorder, points );
  1726.    retain = CC->CompileFlag;
  1727.    (*CC->API.Map2f)( CC, target, u1, u2, ustride, uorder,
  1728.                      v1, v2, vstride, vorder, pnts, retain );
  1729. }
  1730.  
  1731.  
  1732. __asm __saveds void APIENTRY glMapGrid1d( register __d0 GLint un, register __fp0 GLdouble u1, register __fp1 GLdouble u2 )
  1733. {
  1734.    GET_CONTEXT;
  1735.    CHECK_CONTEXT;
  1736.    (*CC->API.MapGrid1f)( CC, un, (GLfloat) u1, (GLfloat) u2 );
  1737. }
  1738.  
  1739.  
  1740. __asm __saveds void APIENTRY glMapGrid1f( register __d0 GLint un, register __fp0 GLfloat u1, register __fp1 GLfloat u2 )
  1741. {
  1742.    GET_CONTEXT;
  1743.    CHECK_CONTEXT;
  1744.    (*CC->API.MapGrid1f)( CC, un, u1, u2 );
  1745. }
  1746.  
  1747.  
  1748. __asm __saveds void APIENTRY glMapGrid2dA(register __a0 void *vargs)
  1749. {
  1750.     struct glMapGrid2dArgs {
  1751.         GLint un;
  1752.         GLdouble u1;
  1753.         GLdouble u2;
  1754.         GLint vn;
  1755.         GLdouble v1;
  1756.         GLdouble v2;
  1757.     } *args;
  1758.  
  1759.     args = (struct glMapGrid2dArgs *)vargs;
  1760.  
  1761.     glMapGrid2d(args->un, args->u1, args->u2, args->vn, args->v1, args->v2);
  1762. }
  1763.  
  1764.  
  1765. __asm __saveds void APIENTRY glMapGrid2d( register __d0 GLint un, register __fp0 GLdouble u1, register __fp1 GLdouble u2,
  1766.                                           register __d1 GLint vn, register __fp2 GLdouble v1, register __fp3 GLdouble v2 )
  1767. {
  1768.    GET_CONTEXT;
  1769.    CHECK_CONTEXT;
  1770.    (*CC->API.MapGrid2f)( CC, un, (GLfloat) u1, (GLfloat) u2,
  1771.                          vn, (GLfloat) v1, (GLfloat) v2 );
  1772. }
  1773.  
  1774.  
  1775. __asm __saveds void APIENTRY glMapGrid2fA(register __a0 void *vargs)
  1776. {
  1777.     struct glMapGrid2fArgs {
  1778.         GLint un;
  1779.         GLfloat u1;
  1780.         GLfloat u2;
  1781.         GLint vn;
  1782.         GLfloat v1;
  1783.         GLfloat v2;
  1784.     } *args;
  1785.  
  1786.     args = (struct glMapGrid2fArgs *)vargs;
  1787.  
  1788.     glMapGrid2f(args->un, args->u1, args->u2, args->vn, args->v1, args->v2);
  1789. }
  1790.  
  1791.  
  1792. __asm __saveds void APIENTRY glMapGrid2f( register __d0 GLint un, register __fp0 GLfloat u1, register __fp1 GLfloat u2,
  1793.                                           register __d1 GLint vn, register __fp2 GLfloat v1, register __fp3 GLfloat v2 )
  1794. {
  1795.    GET_CONTEXT;
  1796.    CHECK_CONTEXT;
  1797.    (*CC->API.MapGrid2f)( CC, un, u1, u2, vn, v1, v2 );
  1798. }
  1799.  
  1800.  
  1801. __asm __saveds void APIENTRY glMaterialf( register __d0 GLenum face, register __d1 GLenum pname, register __fp0 GLfloat param )
  1802. {
  1803.    GLfloat f = param;
  1804.  
  1805.    GET_CONTEXT;
  1806.    CHECK_CONTEXT;
  1807.    (*CC->API.Materialfv)( CC, face, pname, &f );
  1808. }
  1809.  
  1810.  
  1811.  
  1812. __asm __saveds void APIENTRY glMateriali( register __d0 GLenum face, register __d1 GLenum pname, register __d2 GLint param )
  1813. {
  1814.    GLfloat fparam[4];
  1815.    GET_CONTEXT;
  1816.    CHECK_CONTEXT;
  1817.    fparam[0] = (GLfloat) param;
  1818.    (*CC->API.Materialfv)( CC, face, pname, fparam );
  1819. }
  1820.  
  1821.  
  1822. __asm __saveds void APIENTRY glMaterialfv( register __d0 GLenum face, register __d1 GLenum pname, register __a0 const GLfloat *params )
  1823. {
  1824.    GET_CONTEXT;
  1825.    CHECK_CONTEXT;
  1826.    (*CC->API.Materialfv)( CC, face, pname, params );
  1827. }
  1828.  
  1829.  
  1830. __asm __saveds void APIENTRY glMaterialiv( register __d0 GLenum face, register __d1 GLenum pname, register __a0 const GLint *params )
  1831. {
  1832.    GLfloat fparam[4];
  1833.    GET_CONTEXT;
  1834.    CHECK_CONTEXT;
  1835.    switch (pname) {
  1836.       case GL_AMBIENT:
  1837.       case GL_DIFFUSE:
  1838.       case GL_SPECULAR:
  1839.       case GL_EMISSION:
  1840.       case GL_AMBIENT_AND_DIFFUSE:
  1841.          fparam[0] = INT_TO_FLOAT( params[0] );
  1842.          fparam[1] = INT_TO_FLOAT( params[1] );
  1843.          fparam[2] = INT_TO_FLOAT( params[2] );
  1844.          fparam[3] = INT_TO_FLOAT( params[3] );
  1845.          break;
  1846.       case GL_SHININESS:
  1847.          fparam[0] = (GLfloat) params[0];
  1848.          break;
  1849.       case GL_COLOR_INDEXES:
  1850.          fparam[0] = (GLfloat) params[0];
  1851.          fparam[1] = (GLfloat) params[1];
  1852.          fparam[2] = (GLfloat) params[2];
  1853.          break;
  1854.       default:
  1855.          /* Error will be caught later in gl_Materialfv */
  1856.          ;
  1857.    }
  1858.    (*CC->API.Materialfv)( CC, face, pname, fparam );
  1859. }
  1860.  
  1861.  
  1862. __asm __saveds void APIENTRY glMatrixMode( register __d0 GLenum mode )
  1863. {
  1864.    GET_CONTEXT;
  1865.    CHECK_CONTEXT;
  1866.    (*CC->API.MatrixMode)( CC, mode );
  1867. }
  1868.  
  1869.  
  1870. __asm __saveds void APIENTRY glMultMatrixd( register __a0 const GLdouble *m )
  1871. {
  1872.    GLfloat fm[16];
  1873.    GLuint i;
  1874.    GET_CONTEXT;
  1875.    CHECK_CONTEXT;
  1876.  
  1877.    for (i=0;i<16;i++) {
  1878.       fm[i] = (GLfloat) m[i];
  1879.    }
  1880.  
  1881.    (*CC->API.MultMatrixf)( CC, fm );
  1882. }
  1883.  
  1884.  
  1885. __asm __saveds void APIENTRY glMultMatrixf( register __a0 const GLfloat *m )
  1886. {
  1887.    GET_CONTEXT;
  1888.    CHECK_CONTEXT;
  1889.    (*CC->API.MultMatrixf)( CC, m );
  1890. }
  1891.  
  1892.  
  1893. __asm __saveds void APIENTRY glNewList( register __d0 GLuint list, register __d1 GLenum mode )
  1894. {
  1895.    GET_CONTEXT;
  1896.    CHECK_CONTEXT;
  1897.    (*CC->API.NewList)(CC, list, mode);
  1898. }
  1899.  
  1900. __asm __saveds void APIENTRY glNormal3b( register __d0 GLbyte nx, register __d1 GLbyte ny, register __d2 GLbyte nz )
  1901. {
  1902.    GET_CONTEXT;
  1903.    (*CC->API.Normal3f)( CC, BYTE_TO_FLOAT(nx),
  1904.                         BYTE_TO_FLOAT(ny), BYTE_TO_FLOAT(nz) );
  1905. }
  1906.  
  1907.  
  1908. __asm __saveds void APIENTRY glNormal3d( register __fp0 GLdouble nx, register __fp1 GLdouble ny, register __fp2 GLdouble nz )
  1909. {
  1910.    GLfloat fx, fy, fz;
  1911.    GET_CONTEXT;
  1912.    if (ABSD(nx)<0.00001)   fx = 0.0F;   else  fx = nx;
  1913.    if (ABSD(ny)<0.00001)   fy = 0.0F;   else  fy = ny;
  1914.    if (ABSD(nz)<0.00001)   fz = 0.0F;   else  fz = nz;
  1915.    (*CC->API.Normal3f)( CC, fx, fy, fz );
  1916. }
  1917.  
  1918.  
  1919. __asm __saveds void APIENTRY glNormal3f( register __fp0 GLfloat nx, register __fp1 GLfloat ny, register __fp2 GLfloat nz )
  1920. {
  1921.    GET_CONTEXT;
  1922. #ifdef SHORTCUT
  1923.    if (CC->CompileFlag) {
  1924.       (*CC->Save.Normal3f)( CC, nx, ny, nz );
  1925.    }
  1926.    else {
  1927.       /* Execute */
  1928.       CC->Current.Normal[0] = nx;
  1929.       CC->Current.Normal[1] = ny;
  1930.       CC->Current.Normal[2] = nz;
  1931.       CC->VB->MonoNormal = GL_FALSE;
  1932.    }
  1933. #else
  1934.    (*CC->API.Normal3f)( CC, nx, ny, nz );
  1935. #endif
  1936. }
  1937.  
  1938.  
  1939. __asm __saveds void APIENTRY glNormal3i( register __d0 GLint nx, register __d1 GLint ny, register __d2 GLint nz )
  1940. {
  1941.    GET_CONTEXT;
  1942.    (*CC->API.Normal3f)( CC, INT_TO_FLOAT(nx),
  1943.                         INT_TO_FLOAT(ny), INT_TO_FLOAT(nz) );
  1944. }
  1945.  
  1946.  
  1947. __asm __saveds void APIENTRY glNormal3s( register __d0 GLshort nx, register __d1 GLshort ny, register __d2 GLshort nz )
  1948. {
  1949.    GET_CONTEXT;
  1950.    (*CC->API.Normal3f)( CC, SHORT_TO_FLOAT(nx),
  1951.                         SHORT_TO_FLOAT(ny), SHORT_TO_FLOAT(nz) );
  1952. }
  1953.  
  1954.  
  1955. __asm __saveds void APIENTRY glNormal3bv( register __a0 const GLbyte *v )
  1956. {
  1957.    GET_CONTEXT;
  1958.    (*CC->API.Normal3f)( CC, BYTE_TO_FLOAT(v[0]),
  1959.                         BYTE_TO_FLOAT(v[1]), BYTE_TO_FLOAT(v[2]) );
  1960. }
  1961.  
  1962.  
  1963. __asm __saveds void APIENTRY glNormal3dv( register __a0 const GLdouble *v )
  1964. {
  1965.    GLfloat fx, fy, fz;
  1966.    GET_CONTEXT;
  1967.    if (ABSD(v[0])<0.00001)   fx = 0.0F;   else  fx = v[0];
  1968.    if (ABSD(v[1])<0.00001)   fy = 0.0F;   else  fy = v[1];
  1969.    if (ABSD(v[2])<0.00001)   fz = 0.0F;   else  fz = v[2];
  1970.    (*CC->API.Normal3f)( CC, fx, fy, fz );
  1971. }
  1972.  
  1973.  
  1974. __asm __saveds void APIENTRY glNormal3fv( register __a0 const GLfloat *v )
  1975. {
  1976.    GET_CONTEXT;
  1977. #ifdef SHORTCUT
  1978.    if (CC->CompileFlag) {
  1979.       (*CC->Save.Normal3fv)( CC, v );
  1980.    }
  1981.    else {
  1982.       /* Execute */
  1983.       GLfloat *n = CC->Current.Normal;
  1984.       n[0] = v[0];
  1985.       n[1] = v[1];
  1986.       n[2] = v[2];
  1987.       CC->VB->MonoNormal = GL_FALSE;
  1988.    }
  1989. #else
  1990.    (*CC->API.Normal3fv)( CC, v );
  1991. #endif
  1992. }
  1993.  
  1994.  
  1995. __asm __saveds void APIENTRY glNormal3iv( register __a0 const GLint *v )
  1996. {
  1997.    GET_CONTEXT;
  1998.    (*CC->API.Normal3f)( CC, INT_TO_FLOAT(v[0]),
  1999.                         INT_TO_FLOAT(v[1]), INT_TO_FLOAT(v[2]) );
  2000. }
  2001.  
  2002.  
  2003. __asm __saveds void APIENTRY glNormal3sv( register __a0 const GLshort *v )
  2004. {
  2005.    GET_CONTEXT;
  2006.    (*CC->API.Normal3f)( CC, SHORT_TO_FLOAT(v[0]),
  2007.                         SHORT_TO_FLOAT(v[1]), SHORT_TO_FLOAT(v[2]) );
  2008. }
  2009.  
  2010.  
  2011. __asm __saveds void APIENTRY glNormalPointer( register __d0 GLenum type, register __d1 GLsizei stride, register __a0 const GLvoid *ptr )
  2012. {
  2013.    GET_CONTEXT;
  2014.    CHECK_CONTEXT;
  2015.    (*CC->API.NormalPointer)(CC, type, stride, ptr);
  2016. }
  2017.  
  2018.